Chip 2007 January, February, March & April/Chip-Cover-CD-2007-02.iso/Pakiet bezpieczenstwa/mini Pentoo LiveCD 2006.1/mpentoo-2006.1.iso/livecd.squashfs/usr/lib/python2.4/test/test_extcall.pyo

Python Compiled Bytecode | 2005-10-18 | 8KB | 383 lines

# Source Generated with Decompyle++
# File: in.pyo (Python 2.4)

from test.test_support import verify, verbose, TestFailed, sortdict
from UserList import UserList

def e(a, b):
    print a, b


def f(*a, **k):
    print a, sortdict(k)


def g(x, *y, **z):
    print x, y, sortdict(z)


def h(j = 1, a = 2, h = 3):
    print j, a, h

f()
f(1)
f(1, 2)
f(1, 2, 3)
f(1, 2, 3, *(4, 5))
f(1, 2, 3, *[
    4,
    5])
f(1, 2, 3, *UserList([
    4,
    5]))
f(1, 2, 3, **{
    'a': 4,
    'b': 5 })
f(1, 2, 3, *(4, 5), **{
    'a': 6,
    'b': 7 })
f(1, 2, 3, x = 4, y = 5, *(6, 7), **{
    'a': 8,
    'b': 9 })

try:
    e(c = 3)
except TypeError:
    pass

print "should raise TypeError: e() got an unexpected keyword argument 'c'"

try:
    g()
except TypeError:
    err = None
    print 'TypeError:', err

print 'should raise TypeError: not enough arguments; expected 1, got 0'

try:
    g(*())
except TypeError:
    err = None
    print 'TypeError:', err

print 'should raise TypeError: not enough arguments; expected 1, got 0'

try:
    g(*(), **{ })
except TypeError:
    err = None
    print 'TypeError:', err

print 'should raise TypeError: not enough arguments; expected 1, got 0'
g(1)
g(1, 2)
g(1, 2, 3)
g(1, 2, 3, *(4, 5))

class Nothing:
    pass


try:
    g(*Nothing())
except TypeError:
    attr = None

print 'should raise TypeError'

class Nothing:

    def __len__(self):
        return 5



try:
    g(*Nothing())
except TypeError:
    attr = None

print 'should raise TypeError'

class Nothing:

    def __len__(self):
        return 5


    def __getitem__(self, i):
        if i < 3:
            return i
        else:
            raise IndexError, i


g(*Nothing())

class Nothing:

    def __init__(self):
        self.c = 0


    def __iter__(self):
        return self



try:
    g(*Nothing())
except TypeError:
    attr = None

print 'should raise TypeError'

class Nothing:

    def __init__(self):
        self.c = 0


    def __iter__(self):
        return self


    def next(self):
        if self.c == 4:
            raise StopIteration

        c = self.c
        self.c += 1
        return c


g(*Nothing())
d = {
    'a': 1,
    'b': 2,
    'c': 3 }
d2 = d.copy()
verify(d == d2)
g(1, d = 4, **d)
print sortdict(d)
print sortdict(d2)
verify(d == d2, 'function call modified dictionary')

def saboteur(**kw):
    kw['x'] = locals()
    return kw

d = { }
kw = saboteur(a = 1, **d)
verify(d == { })
del kw['x']

try:
    g(1, 2, 3, **{
        'x': 4,
        'y': 5 })
except TypeError:
    err = None
    print err

print 'should raise TypeError: keyword parameter redefined'

try:
    g(1, 2, 3, a = 4, b = 5, *(6, 7), **{
        'a': 8,
        'b': 9 })
except TypeError:
    err = None
    print err

print 'should raise TypeError: keyword parameter redefined'

try:
    f(**{
        1: 2 })
except TypeError:
    err = None
    print err

print 'should raise TypeError: keywords must be strings'

try:
    h(**{
        'e': 2 })
except TypeError:
    err = None
    print err

print 'should raise TypeError: unexpected keyword argument: e'

try:
    h(*h)
except TypeError:
    err = None
    print err

print 'should raise TypeError: * argument must be a tuple'

try:
    dir(*h)
except TypeError:
    err = None
    print err

print 'should raise TypeError: * argument must be a tuple'

try:
    None(*h)
except TypeError:
    err = None
    print err

print 'should raise TypeError: * argument must be a tuple'

try:
    h(**h)
except TypeError:
    err = None
    print err

print 'should raise TypeError: ** argument must be a dictionary'

try:
    dir(**h)
except TypeError:
    err = None
    print err

print 'should raise TypeError: ** argument must be a dictionary'

try:
    None(**h)
except TypeError:
    err = None
    print err

print 'should raise TypeError: ** argument must be a dictionary'

try:
    dir(b = 1, **{
        'b': 1 })
except TypeError:
    err = None
    print err

print "should raise TypeError: dir() got multiple values for keyword argument 'b'"

def f2(*a, **b):
    return (a, b)

d = { }
for i in range(512):
    key = 'k%d' % i
    d[key] = i

(a, b) = f2(1, *(2, 3), **d)
print len(a), len(b), b == d

class Foo:

    def method(self, arg1, arg2):
        return arg1 + arg2


x = Foo()
print Foo.method(*(x, 1, 2))
print Foo.method(x, *(1, 2))

try:
    print Foo.method(*(1, 2, 3))
except TypeError:
    err = None

print 'expected a TypeError for unbound method call'

try:
    print Foo.method(1, *(2, 3))
except TypeError:
    err = None

print 'expected a TypeError for unbound method call'
id(1, **{ })

try:
    id(1, **{
        'foo': 1 })
except TypeError:
    pass

raise TestFailed, 'expected TypeError; no exception raised'
(a, b, d, e, v, k) = ('A', 'B', 'D', 'E', 'V', 'K')
funcs = []
maxargs = { }
for args in [
    '',
    'a',
    'ab']:
    for defargs in [
        '',
        'd',
        'de']:
        for vararg in [
            '',
            'v']:
            for kwarg in [
                '',
                'k']:
                name = 'z' + args + defargs + vararg + kwarg
                arglist = list(args) + map((lambda x: '%s="%s"' % (x, x)), defargs)
                if vararg:
                    arglist.append('*' + vararg)

                if kwarg:
                    arglist.append('**' + kwarg)

                decl = ('def %s(%s): print "ok %s", a, b, d, e, v, ' + 'type(k) is type ("") and k or sortdict(k)') % (name, ', '.join(arglist), name)
                exec decl
                func = eval(name)
                funcs.append(func)
                maxargs[func] = len(args + defargs)




for name in [
    'za',
    'zade',
    'zabk',
    'zabdv',
    'zabdevk']:
    func = eval(name)
    for args in [
        (),
        (1, 2),
        (1, 2, 3, 4, 5)]:
        for kwargs in [
            '',
            'a',
            'd',
            'ad',
            'abde']:
            kwdict = { }
            for k in kwargs:
                kwdict[k] = k + k

            print func.func_name, args, sortdict(kwdict), '->',

            try:
                func(*args, **kwdict)
            continue
            except TypeError:
                err = None
                print err
                continue